home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
SGI Freeware 2002 November
/
SGI Freeware 2002 November - Disc 2.iso
/
dist
/
fw_groff.idb
/
usr
/
freeware
/
info
/
groff-6.z
/
groff-6
Wrap
Text File
|
2002-04-08
|
50KB
|
1,095 lines
This is groff, produced by makeinfo version 4.0 from groff.texinfo.
INFO-DIR-SECTION Miscellaneous
START-INFO-DIR-ENTRY
* Groff: (groff). The GNU troff document formatting system.
END-INFO-DIR-ENTRY
This Info file documents GNU troff version 1.16.
Published by the Free Software Foundation 59 Temple Place, Suite 330
Boston, MA 02111-1307 USA
Copyright (C) 1994-2000 Free Software Foundation, Inc.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.
Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "GNU General Public License" is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.
Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "GNU General Public License"
may be included in a translation approved by the Free Software
Foundation instead of in the original English.
File: groff, Node: Output Format, Next: Device Control, Prev: gtroff Output, Up: gtroff Output
Output Format
-------------
The output format is text based, as opposed to a binary format (like
TeX DVI). The output format is 8-bit clean, thus single characters can
have the eighth bit set, as can the names of fonts and special
characters.
The output format consists of single command characters with attached
parameters which are separated from subsequent text by whitespace or a
newline.
The names of characters and fonts can be of arbitrary length; drivers
should not assume that they are only two characters long (as `ditroff'
does).
When a character is to be printed, that character is always in the
current font. Unlike `ditroff', it is not necessary for drivers to
search special fonts to find a character.
`HN'
`VN'
`hN'
`vN'
`cN'
`CN'
`NNC'
`tXXX'
XXX is any sequence of characters terminated by a space or a
newline; the first character should be printed at the current
position, the the current horizontal position should be increased
by the width of the first character, and so on for each character.
The width of the character is that given in the font file,
appropriately scaled for the current point size, and rounded so
that it is a multiple of the horizontal resolution. Special
characters cannot be printed using this command.
This command is only allowed if the `tcommand' line is present in
the `DESC' file.
`uN XXX'
This is same as the `t' command except that after printing each
character, the current horizontal position is increased by the sum
of the width of that character and N.
This command is only allowed if the `tcommand' line is present in
the `DESC' file.
`nAB'
`pN'
`sN'
The argument to the `s' command is in scaled points (units of
points/N, where N is the argument to the `sizescale' command in
the `DESC' file).
`fN'
`x ... \n'
Device control.
`DC X...\n'
File: groff, Node: Device Control, Next: Drawing Functions, Prev: Output Format, Up: gtroff Output
Device Control
--------------
The `x' command is normally followed by a letter or word indicating
the function to perform, followed by white space separated arguments.
The first argument can be abbreviated to the first letter.
`x init'
`x T'
`x res N H V'
`x H'
The argument to the `x Height' command is also in scaled points.
The first three output commands are guaranteed to be:
x T device
x res n h v
x init
For example, the input
crunchy \fH\s+2frog\s0\fP!?
produces
File: groff, Node: Drawing Functions, Next: Line Continuation, Prev: Device Control, Up: gtroff Output
Drawing Functions
-----------------
The `D' drawing command has been extended. These extensions are
used by GNU `pic' only if the `-x' option is given.
*Note Drawing Requests::.
`Df N'
Set the shade of gray to be used for filling solid objects to N;
N must be an integer between 0 and 1000, where 0 corresponds solid
white and 1000 to solid black, and values in between correspond to
intermediate shades of gray. This applies only to solid circles,
solid ellipses and solid polygons. By default, a level of 1000 is
used. Whatever color a solid object has, it should completely
obscure everything beneath it. A value greater than 1000 or less
than 0 can also be used: this means fill with the shade of gray
that is currently being used for lines and text. Normally this is
black, but some drivers may provide a way of changing this.
`DC D'
Draw a solid circle with a diameter of D with the leftmost point
at the current position.
`DE DX DY'
Draw a solid ellipse with a horizontal diameter of DX and a
vertical diameter of DY with the leftmost point at the current
position.
`Dp DX1 DY1 DX2 DY2 ... DXN DYN'
Draw a polygon with automatic closure. The first vertex is at the
current position, the second vertex at an offset (DX1,DY1) from
the current position, the second vertex at an offset (DX2,DY2)
from the first vertex, and so on up to the Nth vertex. At the
moment, GNU `pic' only uses this command to generate triangles and
rectangles.
`DP DX1 DY1 DX2 DY2 ... DXN DYN'
Like `Dp' but draw a solid rather than outlined polygon.
`Dt N'
Set the current line thickness to N machine units. Traditionally,
UNIX `troff' drivers use a line thickness proportional to the
current point size; drivers should continue to do this if no `Dt'
command has been given, or if a `Dt' command has been given with a
negative value of N. A zero value of N selects the smallest
available line thickness.
A difficulty arises in how the current position should be changed
after the execution of these commands. This is not of great importance
since the code generated by GNU `pic' does not depend on this. Given a
drawing command of the form
\D'C X1 Y1 X2 Y2 ... XN YN'
where C is not one of `c', `e', `l', `a' or `~', UNIX `troff' treats
each x value as a horizontal quantity, and each y value as a vertical
quantity; it assumes that the width of the drawn object is the sum of
all x values, and that the height is the sum of all y values. (The
assumption about the height can be seen by examining the `st' and `sb'
registers after using such a `D' command in a `\w' escape sequence.)
This rule also holds for all the original drawing commands with the
exception of `De'. For the sake of compatibility GNU `troff' also
follows this rule, even though it produces an ugly result in the case
of the `Df', `Dt', and, to a lesser extent, `DE' commands. Thus after
executing a `D' command of the form
DC X1 Y1 X2 Y2 ... XN YN
the current position should be increased horizontally by the sum of all
x values and vertically by the sum of all y values.
File: groff, Node: Line Continuation, Prev: Drawing Functions, Up: gtroff Output
Line Continuation
-----------------
There is a continuation convention which permits the argument to the
`x X' command to contain newlines: When outputting the argument to the
`x X' command, GNU `troff' follows each newline in the argument with a
`+' character (as usual, it terminates the entire argument with a
newline); thus if the line after the line containing the `x X' command
starts with `+', then the newline ending the line containing the `x X'
command should be treated as part of the argument to the `x X' command,
the `+' should be ignored, and the part of the line following the `+'
should be treated like the part of the line following the `x X' command.
File: groff, Node: Font Files, Prev: gtroff Output, Up: File formats
Font Files
==========
The `gtroff' font format is roughly a superset of the `ditroff' font
format. Unlike the `ditroff' font format, there is no associated
binary format; all files are text files. The font files for device
NAME are stored in a directory `devNAME'. There are two types of file:
a device description file called `DESC' and for each font F a font file
called `F'.
* Menu:
* DESC File Format::
* Font File Format::
File: groff, Node: DESC File Format, Next: Font File Format, Prev: Font Files, Up: Font Files
`DESC' File Format
------------------
The `DESC' file can contain the following types of line:
`res N'
There are N machine units per inch.
`hor N'
The horizontal resolution is N machine units.
`vert N'
The vertical resolution is N machine units.
`sizescale N'
The scale factor for point sizes. By default this has a value
of 1. One scaled point is equal to one point/N. The arguments to
the `unitwidth' and `sizes' commands are given in scaled points.
*Note Fractional Type Sizes::, for more information.
`unitwidth N'
Quantities in the font files are given in machine units for fonts
whose point size is N scaled points.
`tcommand'
This means that the postprocessor can handle the `t' and `u'
output commands.
`sizes S1 S2 ... SN 0'
This means that the device has fonts at S1, S2, ... SN scaled
points. The list of sizes must be terminated by a 0. Each SI can
also be a range of sizes M-N. The list can extend over more than
one line.
`styles S1 S2 ... SM'
The first M font positions are associated with styles S1 ... SM.
`fonts N F1 F2 F3 ... FN'
Fonts F1 ... FN are mounted in the font positions M+1, ..., M+N
where M is the number of styles. This command may extend over
more than one line. A font name of 0 means no font is mounted on
the corresponding font position.
`family FAM'
The default font family is FAM.
`charset'
This line and everything following in the file are ignored. It is
allowed for the sake of backwards compatibility.
The `res', `unitwidth', `fonts' and `sizes' lines are mandatory.
Other commands are ignored by `gtroff' but may be used by
postprocessors to store arbitrary information about the device in the
`DESC' file.
File: groff, Node: Font File Format, Prev: DESC File Format, Up: Font Files
Font File Format
----------------
A font file has two sections. The first section is a sequence of
lines each containing a sequence of blank delimited words; the first
word in the line is a key, and subsequent words give a value for that
key.
`name F'
The name of the font is F.
`spacewidth N'
The normal width of a space is N.
`slant N'
The characters of the font have a slant of N degrees. (Positive
means forward.)
`ligatures LIG1 LIG2 ... LIGN [0]'
Characters LIG1, LIG2, ..., LIGN are ligatures; possible ligatures
are `ff', `fi', `fl', `ffi' and `ffl'. For backwards
compatibility, the list of ligatures may be terminated with a 0.
The list of ligatures may not extend over more than one line.
`special'
The font is special; this means that when a character is requested
that is not present in the current font, it is searched for in any
special fonts that are mounted.
Other commands are ignored by `gtroff' but may be used by
postprocessors to store arbitrary information about the font in the font
file.
The first section can contain comments which start with the `#'
character and extend to the end of a line.
The second section contains one or two subsections. It must contain
a `charset' subsection and it may also contain a `kernpairs'
subsection. These subsections can appear in any order. Each
subsection starts with a word on a line by itself.
The word `charset' starts the character set subsection. The
`charset' line is followed by a sequence of lines. Each line gives
information for one character. A line comprises a number of fields
separated by blanks or tabs. The format is
NAME METRICS TYPE CODE COMMENT
NAME identifies the character: If NAME is a single character C then it
corresponds to the `gtroff' input character C; if it is of the form
`\C' where C is a single character, then it corresponds to the `gtroff'
input character \C; otherwise it corresponds to the groff input
character `\[NAME]'. (If it is exactly two characters XX it can be
entered as `\(XX'.) `gtroff' supports 8-bit characters; however some
utilities have difficulties with eight-bit characters. For this
reason, there is a convention that the name `charN' is equivalent to
the single character whose code is N. For example, `char163' would be
equivalent to the character with code 163 which is the pounds sterling
sign in ISO Latin-1 character set. The name `---' is special and
indicates that the character is unnamed; such characters can only be
used by means of the `\N' escape sequence in `gtroff'.
The TYPE field gives the character type:
`1'
the character has an descender, for example, `p';
`2'
the character has an ascender, for example, `b';
`3'
the character has both an ascender and a descender, for example,
`('.
The CODE field gives the code which the postprocessor uses to print
the character. The character can also be input to `gtroff' using this
code by means of the `\N' escape sequence. The code can be any
integer. If it starts with `0' it is interpreted as octal; if it
starts with `0x' or `0X' it is interpreted as hexadecimal.
Anything on the line after the CODE field is ignored.
The METRICS field has the form:
WIDTH[,HEIGHT[,DEPTH[,ITALIC_CORRECTION
[,LEFT_ITALIC_CORRECTION[,SUBSCRIPT_CORRECTION]]]]]
There must not be any spaces between these subfields (it has been split
here into two lines for better legibility only). Missing subfields are
assumed to be 0. The subfields are all decimal integers. Since there
is no associated binary format, these values are not required to fit
into a variable of type `char' as they are in `ditroff'. The WIDTH
subfield gives the width of the character. The HEIGHT subfield gives
the height of the character (upwards is positive); if a character does
not extend above the baseline, it should be given a zero height, rather
than a negative height. The DEPTH subfield gives the depth of the
character, that is, the distance below the lowest point below the
baseline to which the character extends (downwards is positive); if a
character does not extend below above the baseline, it should be given
a zero depth, rather than a negative depth. The ITALIC_CORRECTION
subfield gives the amount of space that should be added after the
character when it is immediately to be followed by a character from a
roman font. The LEFT_ITALIC_CORRECTION subfield gives the amount of
space that should be added before the character when it is immediately
to be preceded by a character from a roman font. The
SUBSCRIPT_CORRECTION gives the amount of space that should be added
after a character before adding a subscript. This should be less than
the italic correction.
A line in the `charset' section can also have the format
NAME "
This indicates that NAME is just another name for the character
mentioned in the preceding line.
The word `kernpairs' starts the kernpairs section. This contains a
sequence of lines of the form:
C1 C2 N
This means that when character C1 appears next to character C2 the
space between them should be increased by N. Most entries in the
kernpairs section have a negative value for N.
File: groff, Node: Installation, Next: Request Index, Prev: File formats, Up: Top
Installation
************
File: groff, Node: Request Index, Next: Escape Index, Prev: Installation, Up: Top
Request Index
*************
Requests appear without the leading control character (normally
either `.' or `'').
* Menu:
* ' <1>: Character Translations.
* ' <2>: Requests.
* ' <3>: Escapes.
* ': Comments.
* ( <1>: Escapes.
* (: Identifiers.
* . <1>: Requests.
* .: Character Translations.
* [ <1>: Escapes.
* [: Identifiers.
* ] <1>: Escapes.
* ]: Identifiers.
* ab: Debugging.
* ad <1>: Manipulating Hyphenation.
* ad: Manipulating Filling and Adjusting.
* af: Assigning Formats.
* aln: Setting Registers.
* als <1>: Writing Macros.
* als <2>: Parameters.
* als: Strings.
* am: Writing Macros.
* as <1>: Strings.
* as: Comments.
* asciify: Diversions.
* backtrace: Debugging.
* bd <1>: Changing Fonts.
* bd <2>: Artificial Fonts.
* bd <3>: Font Families.
* bd: Implementation Differences.
* blm <1>: Implicit Line Breaks.
* blm: Requests.
* bp <1>: Manipulating Filling and Adjusting.
* bp: Page Control.
* br <1>: Manipulating Filling and Adjusting.
* br: Basics.
* break: while.
* c2: Character Translations.
* cc: Character Translations.
* ce <1>: Manipulating Filling and Adjusting.
* ce: Basics.
* cf <1>: I/O.
* cf: Manipulating Filling and Adjusting.
* cflags: Using Symbols.
* ch: Page Location Traps.
* char <1>: Character Translations.
* char <2>: Using Symbols.
* char <3>: Operators in Conditionals.
* char <4>: Using Symbols.
* char: Manipulating Hyphenation.
* chop: Strings.
* close: I/O.
* code: Changing Fonts.
* continue: while.
* cp <1>: Using Symbols.
* cp: Implementation Differences.
* cs <1>: Implementation Differences.
* cs <2>: Font Families.
* cs <3>: Fractional Type Sizes.
* cs <4>: Changing Fonts.
* cs: Artificial Fonts.
* cu: Artificial Fonts.
* da <1>: Diversions.
* da: Warnings.
* de <1>: Warnings.
* de <2>: while.
* de: Writing Macros.
* di <1>: Warnings.
* di: Diversions.
* ds <1>: Comments.
* ds <2>: Strings.
* ds: Request Arguments.
* dt: Diversion Traps.
* ec: Character Translations.
* el <1>: if-else.
* el: Warnings.
* em: End-of-input Traps.
* eo: Character Translations.
* ev: Environments.
* evc: Environments.
* ex <1>: I/O.
* ex: Debugging.
* fam <1>: Font Families.
* fam <2>: Changing Fonts.
* fam: Font Positions.
* fc: Fields.
* fi: Manipulating Filling and Adjusting.
* fl <1>: Manipulating Filling and Adjusting.
* fl: Debugging.
* fp <1>: Font Positions.
* fp <2>: Changing Fonts.
* fp: Implementation Differences.
* fspecial <1>: Changing Fonts.
* fspecial <2>: Using Symbols.
* fspecial <3>: Font Families.
* fspecial: Artificial Fonts.
* ft <1>: Changing Fonts.
* ft: Font Positions.
* ftr: Changing Fonts.
* hc: Manipulating Hyphenation.
* hcode <1>: Manipulating Hyphenation.
* hcode: Using Symbols.
* hla: Manipulating Hyphenation.
* hlm: Manipulating Hyphenation.
* hpf: Manipulating Hyphenation.
* hw: Manipulating Hyphenation.
* hy: Manipulating Hyphenation.
* hym: Manipulating Hyphenation.
* hys: Manipulating Hyphenation.
* ie <1>: if-else.
* ie: Warnings.
* if <1>: Expressions.
* if <2>: if-else.
* if: Operators in Conditionals.
* ig: Comments.
* in <1>: Line Layout.
* in <2>: Manipulating Filling and Adjusting.
* in <3>: Line Layout.
* in: Manipulating Filling and Adjusting.
* it: Input Line Traps.
* kern: Ligatures and Kerning.
* lc <1>: Using Symbols.
* lc: Leaders.
* length: Strings.
* lf: Miscellaneous.
* lg: Ligatures and Kerning.
* ll <1>: Line Layout.
* ll: Manipulating Filling and Adjusting.
* ls <1>: Manipulating Spacing.
* ls: Basics.
* lt: Page Layout.
* mc: Miscellaneous.
* mk: Page Motions.
* mso: I/O.
* na: Manipulating Filling and Adjusting.
* ne <1>: Page Control.
* ne: Page Location Traps.
* nf: Manipulating Filling and Adjusting.
* nh: Manipulating Hyphenation.
* nm <1>: Built-in Registers.
* nm: Miscellaneous.
* nn: Miscellaneous.
* nr <1>: Auto-increment.
* nr <2>: Setting Registers.
* nr: Warnings.
* nroff <1>: Operators in Conditionals.
* nroff: Troff and Nroff Mode.
* ns: Manipulating Spacing.
* nx: I/O.
* open: I/O.
* opena: I/O.
* os: Page Control.
* pc: Page Layout.
* pi: I/O.
* pl: Page Layout.
* pm: Debugging.
* pn <1>: Page Layout.
* pn: Page Control.
* pnr: Debugging.
* po: Line Layout.
* ps <1>: Changing Type Sizes.
* ps <2>: Artificial Fonts.
* ps <3>: Changing Type Sizes.
* ps <4>: Implementation Differences.
* ps: Fractional Type Sizes.
* ptr: Debugging.
* rc: Using Symbols.
* rchar: Using Symbols.
* rd: I/O.
* rj: Manipulating Filling and Adjusting.
* rm: Strings.
* rn: Strings.
* rnn: Setting Registers.
* rr: Setting Registers.
* rs: Manipulating Spacing.
* rt: Page Motions.
* shc <1>: Character Translations.
* shc: Manipulating Hyphenation.
* shift: Parameters.
* so: I/O.
* sp <1>: Manipulating Spacing.
* sp <2>: Page Motions.
* sp <3>: Manipulating Spacing.
* sp: Manipulating Filling and Adjusting.
* special: Changing Fonts.
* ss: Manipulating Filling and Adjusting.
* sty <1>: Font Positions.
* sty <2>: Changing Fonts.
* sty: Font Families.
* substring: Strings.
* sv: Page Control.
* sy: I/O.
* ta: Tabs and Fields.
* tc: Tabs and Fields.
* ti <1>: Line Layout.
* ti: Manipulating Filling and Adjusting.
* tkf <1>: Fractional Type Sizes.
* tkf <2>: Implementation Differences.
* tkf <3>: Ligatures and Kerning.
* tkf <4>: Font Families.
* tkf: Changing Fonts.
* tl: Page Layout.
* tm: Debugging.
* tr <1>: Implementation Differences.
* tr <2>: Character Translations.
* tr <3>: Using Symbols.
* tr: Manipulating Hyphenation.
* trf <1>: Manipulating Filling and Adjusting.
* trf: I/O.
* trnt: Character Translations.
* troff <1>: Operators in Conditionals.
* troff: Troff and Nroff Mode.
* uf <1>: Font Families.
* uf: Artificial Fonts.
* ul <1>: Artificial Fonts.
* ul <2>: Changing Fonts.
* ul: Artificial Fonts.
* unformat <1>: Gtroff Internals.
* unformat: Strings.
* vpt: Page Location Traps.
* vs: Changing Type Sizes.
* warn: Debugging.
* wh: Page Location Traps.
* while <1>: while.
* while <2>: Expressions.
* while: Operators in Conditionals.
* write: I/O.
File: groff, Node: Escape Index, Next: Operator Index, Prev: Request Index, Up: Top
Escape Index
************
* Menu:
* \: Using Symbols.
* \! <1>: Implementation Differences.
* \! <2>: Diversions.
* \! <3>: Escapes.
* \! <4>: Character Translations.
* \!: Escapes.
* \": Comments.
* \#: Comments.
* \$ <1>: Parameters.
* \$ <2>: Copy-in Mode.
* \$: Parameters.
* \$*: Parameters.
* \$0: Parameters.
* \$@: Parameters.
* \% <1>: Implementation Differences.
* \% <2>: Escapes.
* \% <3>: Manipulating Hyphenation.
* \% <4>: Character Translations.
* \%: Escapes.
* \& <1>: Drawing Requests.
* \& <2>: Escapes.
* \& <3>: Using Symbols.
* \& <4>: Character Translations.
* \& <5>: Ligatures and Kerning.
* \& <6>: Sentences.
* \& <7>: Requests.
* \&: Implementation Differences.
* \' <1>: Character Translations.
* \' <2>: Implementation Differences.
* \': Escapes.
* \(: Character Translations.
* \): Escapes.
* \* <1>: Implementation Differences.
* \* <2>: Copy-in Mode.
* \*: Strings.
* \, <1>: Escapes.
* \,: Ligatures and Kerning.
* \- <1>: Escapes.
* \- <2>: Implementation Differences.
* \- <3>: Character Translations.
* \-: Escapes.
* \/ <1>: Ligatures and Kerning.
* \/: Escapes.
* \0: Escapes.
* \<RET> <1>: Copy-in Mode.
* \<RET>: Strings.
* \<SP> <1>: Implementation Differences.
* \<SP> <2>: Request Arguments.
* \<SP>: Escapes.
* \? <1>: Implementation Differences.
* \? <2>: Diversions.
* \?: Escapes.
* \@: Escapes.
* \[: Character Translations.
* \\ <1>: Character Translations.
* \\ <2>: Copy-in Mode.
* \\: Escapes.
* \^ <1>: Implementation Differences.
* \^: Escapes.
* \_ <1>: Character Translations.
* \_ <2>: Escapes.
* \_: Implementation Differences.
* \` <1>: Implementation Differences.
* \` <2>: Escapes.
* \` <3>: Character Translations.
* \`: Escapes.
* \A: Identifiers.
* \a <1>: Character Translations.
* \a: Escapes.
* \A: Escapes.
* \a: Leaders.
* \A: Implementation Differences.
* \b <1>: Drawing Requests.
* \b: Escapes.
* \C: Escapes.
* \c: Escapes.
* \C: Using Symbols.
* \c: Implementation Differences.
* \C: Character Translations.
* \c: Escapes.
* \D: Escapes.
* \d: Escapes.
* \D <1>: Drawing Functions.
* \D: Drawing Requests.
* \e <1>: Using Symbols.
* \e: Escapes.
* \E: Escapes.
* \e: Escapes.
* \E: Escapes.
* \e <1>: Escapes.
* \e <2>: Character Translations.
* \e: Implementation Differences.
* \f <1>: Changing Fonts.
* \f <2>: Font Positions.
* \f <3>: Changing Fonts.
* \f <4>: Font Positions.
* \f: Changing Fonts.
* \g: Assigning Formats.
* \h: Page Motions.
* \H <1>: Fractional Type Sizes.
* \H: Escapes.
* \h: Escapes.
* \k: Page Motions.
* \l: Using Symbols.
* \L: Drawing Requests.
* \l: Drawing Requests.
* \L: Escapes.
* \l: Escapes.
* \L: Using Symbols.
* \n <1>: Copy-in Mode.
* \n: Implementation Differences.
* \N <1>: Escapes.
* \N: Font File Format.
* \n <1>: Auto-increment.
* \n <2>: Interpolating Registers.
* \n <3>: Auto-increment.
* \n: Interpolating Registers.
* \N <1>: Character Translations.
* \N: Using Symbols.
* \o: Escapes.
* \O: Suppressing output.
* \p <1>: Escapes.
* \p: Manipulating Filling and Adjusting.
* \R: Setting Registers.
* \r: Escapes.
* \R <1>: Setting Registers.
* \R <2>: Escapes.
* \R: Auto-increment.
* \s <1>: Fractional Type Sizes.
* \s <2>: Escapes.
* \s: Changing Type Sizes.
* \S: Escapes.
* \t <1>: Character Translations.
* \t <2>: Tabs and Fields.
* \t: Escapes.
* \u: Escapes.
* \V: I/O.
* \v <1>: Gtroff Internals.
* \v <2>: Escapes.
* \v: Page Motions.
* \w <1>: Drawing Functions.
* \w <2>: Page Motions.
* \w: Escapes.
* \X <1>: Escapes.
* \X: Postprocessor Access.
* \x <1>: Escapes.
* \x: Manipulating Spacing.
* \Y: Postprocessor Access.
* \Z: Escapes.
* \{ <1>: Escapes.
* \{ <2>: Implementation Differences.
* \{ <3>: Escapes.
* \{: if-else.
* \| <1>: Implementation Differences.
* \|: Escapes.
* \} <1>: Escapes.
* \} <2>: if-else.
* \} <3>: Warnings.
* \} <4>: Escapes.
* \}: Implementation Differences.
* \~ <1>: Character Translations.
* \~ <2>: Request Arguments.
* \~: Escapes.
File: groff, Node: Operator Index, Next: Register Index, Prev: Escape Index, Up: Top
Operator Index
**************
* Menu:
* !: Expressions.
* % <1>: Escapes.
* %: Expressions.
* & <1>: Escapes.
* &: Expressions.
* ( <1>: Expressions.
* (: Escapes.
* ) <1>: Escapes.
* ): Expressions.
* * <1>: Escapes.
* *: Expressions.
* + <1>: Expressions.
* + <2>: Escapes.
* +: Expressions.
* +, and page motion: Expressions.
* - <1>: Expressions.
* - <2>: Escapes.
* -: Expressions.
* -, and page motion: Expressions.
* .: Escapes.
* / <1>: Expressions.
* /: Escapes.
* : <1>: Escapes.
* :: Expressions.
* < <1>: Expressions.
* <: Escapes.
* <=: Expressions.
* <?: Expressions.
* = <1>: Escapes.
* =: Expressions.
* ==: Expressions.
* > <1>: Escapes.
* >: Expressions.
* >=: Expressions.
* >?: Expressions.
* |: Drawing Requests.
* |, and page motion: Expressions.
File: groff, Node: Register Index, Next: Macro Index, Prev: Operator Index, Up: Top
Register Index
**************
* Menu:
* %: Page Layout.
* .$: Parameters.
* .A: Built-in Registers.
* .a: Manipulating Spacing.
* .A: Groff Options.
* .b: Artificial Fonts.
* .C: Implementation Differences.
* .c: Built-in Registers.
* .ce: Manipulating Filling and Adjusting.
* .d: Diversions.
* .ev: Environments.
* .f: Font Positions.
* .fam: Font Families.
* .fp: Font Positions.
* .g: Built-in Registers.
* .h: Diversions.
* .H: Built-in Registers.
* .hla: Manipulating Hyphenation.
* .hlc: Manipulating Hyphenation.
* .hlm: Manipulating Hyphenation.
* .hy: Manipulating Hyphenation.
* .hym: Manipulating Hyphenation.
* .hys: Manipulating Hyphenation.
* .i: Line Layout.
* .in: Line Layout.
* .j: Manipulating Filling and Adjusting.
* .k: Page Motions.
* .kern: Ligatures and Kerning.
* .l: Line Layout.
* .L: Manipulating Spacing.
* .lg: Ligatures and Kerning.
* .ll: Line Layout.
* .lt: Page Layout.
* .ne: Page Location Traps.
* .ns: Manipulating Spacing.
* .o: Line Layout.
* .p: Page Layout.
* .P <1>: Built-in Registers.
* .P: Groff Options.
* .pn: Page Layout.
* .ps: Fractional Type Sizes.
* .psr: Fractional Type Sizes.
* .rj: Manipulating Filling and Adjusting.
* .s <1>: Changing Type Sizes.
* .s: Fractional Type Sizes.
* .sr: Fractional Type Sizes.
* .ss: Manipulating Filling and Adjusting.
* .sss: Manipulating Filling and Adjusting.
* .T <1>: Built-in Registers.
* .T: Groff Options.
* .t <1>: Page Location Traps.
* .t: Diversion Traps.
* .tabs: Tabs and Fields.
* .trunc: Page Location Traps.
* .u: Manipulating Filling and Adjusting.
* .v: Changing Type Sizes.
* .V <1>: Built-in Registers.
* .V: Changing Type Sizes.
* .vpt: Page Location Traps.
* .warn: Debugging.
* .x: Built-in Registers.
* .Y: Built-in Registers.
* .y: Built-in Registers.
* .z: Diversions.
* c.: Built-in Registers.
* ct: Page Motions.
* dl: Diversions.
* dn: Diversions.
* dw: Built-in Registers.
* dy: Built-in Registers.
* ln: Built-in Registers.
* mo: Built-in Registers.
* nl: Diversions.
* opmaxx: Suppressing output.
* opmaxy: Suppressing output.
* opminx: Suppressing output.
* opminy: Suppressing output.
* rsb: Page Motions.
* rst: Page Motions.
* sb <1>: Drawing Functions.
* sb: Page Motions.
* skw: Page Motions.
* ssc: Page Motions.
* st <1>: Drawing Functions.
* st: Page Motions.
* systat: I/O.
* year: Built-in Registers.
* yr: Built-in Registers.
File: groff, Node: Macro Index, Next: String Index, Prev: Register Index, Up: Top
Macro Index
***********
* Menu:
* B: Man font macros.
* BI: Man font macros.
* BR: Man font macros.
* DT: Miscellaneous man macros.
* HP <1>: Man usage.
* HP: Miscellaneous man macros.
* I: Man font macros.
* IB: Man font macros.
* IP <1>: Miscellaneous man macros.
* IP: Man usage.
* IR: Man font macros.
* LP <1>: Man usage.
* LP <2>: Miscellaneous man macros.
* LP: Man usage.
* P <1>: Man usage.
* P: Miscellaneous man macros.
* PD: Miscellaneous man macros.
* PP <1>: Miscellaneous man macros.
* PP: Man usage.
* R: Man font macros.
* RB: Man font macros.
* RE: Man usage.
* RI: Man font macros.
* RS: Man usage.
* SB: Man font macros.
* SH <1>: Man usage.
* SH: Miscellaneous man macros.
* SM: Man font macros.
* SS <1>: Man usage.
* SS: Miscellaneous man macros.
* TH <1>: Man usage.
* TH: Miscellaneous man macros.
* TP <1>: Man usage.
* TP <2>: Miscellaneous man macros.
* TP: Man usage.
File: groff, Node: String Index, Next: Glyph Name Index, Prev: Macro Index, Up: Top
String Index
************
* Menu:
* *R: Predefined man strings.
* *S: Predefined man strings.
* .T <1>: Groff Options.
* .T: Built-in Registers.
* lq: Predefined man strings.
* rq: Predefined man strings.
* Tm: Predefined man strings.
File: groff, Node: Glyph Name Index, Next: Font File Keyword Index, Prev: String Index, Up: Top
Glyph Name Index
****************
A glyph name `xx' consisting of exactly two characters can be
accessed as `\(xx'. Glyph names `xxx' of any length can be accessed as
`\[xxx]'.
* Menu:
* br: Using Symbols.
* dg <1>: Using Symbols.
* dg: Sentences.
* em: Using Symbols.
* hy <1>: Manipulating Hyphenation.
* hy: Using Symbols.
* lq: Predefined man strings.
* rn: Using Symbols.
* rq <1>: Predefined man strings.
* rq <2>: Sentences.
* rq: Using Symbols.
* ru: Using Symbols.
* ul: Using Symbols.
